ജാവാസ്ക്രിപ്റ്റ് അസിങ്ക് ഇറ്ററേറ്റർ പാറ്റേൺ: സ്ട്രീം ഡിസൈനിനായുള്ള ഒരു സമഗ്ര ഗൈഡ്

ആധുനിക ജാവാസ്ക്രിപ്റ്റ് ഡെവലപ്‌മെൻ്റിൽ, പ്രത്യേകിച്ച് ഡാറ്റാ-ഇൻ്റൻസീവ് ആപ്ലിക്കേഷനുകൾ അല്ലെങ്കിൽ റിയൽ-ടൈം ഡാറ്റാ സ്ട്രീമുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ, കാര്യക്ഷമവും അസിൻക്രണസുമായ ഡാറ്റാ പ്രോസസ്സിംഗിൻ്റെ ആവശ്യകത വളരെ പ്രധാനമാണ്. ECMAScript 2018-ൽ അവതരിപ്പിച്ച അസിങ്ക് ഇറ്ററേറ്റർ പാറ്റേൺ, ഡാറ്റാ സ്ട്രീമുകൾ അസിൻക്രണസായി കൈകാര്യം ചെയ്യുന്നതിന് ശക്തവും ലളിതവുമായ ഒരു പരിഹാരം നൽകുന്നു. ഈ ബ്ലോഗ് പോസ്റ്റ് അസിങ്ക് ഇറ്ററേറ്റർ പാറ്റേണിൻ്റെ ആഴങ്ങളിലേക്ക് കടന്നുചെല്ലുന്നു, അതിൻ്റെ ആശയങ്ങൾ, നടപ്പാക്കൽ, ഉപയോഗങ്ങൾ, വിവിധ സാഹചര്യങ്ങളിലെ ഗുണങ്ങൾ എന്നിവ പര്യവേക്ഷണം ചെയ്യുന്നു. ആഗോളതലത്തിൽ ആധുനിക വെബ് ആപ്ലിക്കേഷനുകൾക്ക് അത്യന്താപേക്ഷിതമായ, ഡാറ്റാ സ്ട്രീമുകൾ കാര്യക്ഷമമായും അസിൻക്രണസായും കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു ഗെയിം ചേഞ്ചറാണിത്.

ഇറ്ററേറ്ററുകളും ജനറേറ്ററുകളും മനസ്സിലാക്കുന്നു

അസിങ്ക് ഇറ്ററേറ്ററുകളിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, ജാവാസ്ക്രിപ്റ്റിലെ ഇറ്ററേറ്ററുകളുടെയും ജനറേറ്ററുകളുടെയും അടിസ്ഥാന ആശയങ്ങൾ നമുക്ക് സംക്ഷിപ്തമായി പരിശോധിക്കാം. ഇവയാണ് അസിങ്ക് ഇറ്ററേറ്ററുകൾ നിർമ്മിച്ചിരിക്കുന്നതിൻ്റെ അടിസ്ഥാനം.

ഇറ്ററേറ്ററുകൾ

ഒരു ഇറ്ററേറ്റർ എന്നത് ഒരു ശ്രേണി നിർവചിക്കുകയും, അവസാനം, ഒരുപക്ഷേ ഒരു റിട്ടേൺ മൂല്യം നൽകുകയും ചെയ്യുന്ന ഒരു ഒബ്ജക്റ്റാണ്. പ്രത്യേകിച്ചും, ഒരു ഇറ്ററേറ്റർ രണ്ട് പ്രോപ്പർട്ടികളുള്ള ഒരു ഒബ്ജക്റ്റ് നൽകുന്ന ഒരു next() മെത്തേഡ് നടപ്പിലാക്കുന്നു:

• value: ശ്രേണിയിലെ അടുത്ത മൂല്യം.
• done: ഇറ്ററേറ്റർ ശ്രേണിയിലൂടെയുള്ള ഇറ്ററേഷൻ പൂർത്തിയാക്കിയോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ. done true ആകുമ്പോൾ, value സാധാരണയായി ഇറ്ററേറ്ററിൻ്റെ റിട്ടേൺ മൂല്യമായിരിക്കും, എന്തെങ്കിലും ഉണ്ടെങ്കിൽ.

ഒരു സിൻക്രണസ് ഇറ്ററേറ്ററിൻ്റെ ലളിതമായ ഉദാഹരണം ഇതാ:

            
const myIterator = {
  data: [1, 2, 3],
  index: 0,
  next() {
    if (this.index < this.data.length) {
      return { value: this.data[this.index++], done: false };
    } else {
      return { value: undefined, done: true };
    }
  },
};

console.log(myIterator.next()); // Output: { value: 1, done: false }
console.log(myIterator.next()); // Output: { value: 2, done: false }
console.log(myIterator.next()); // Output: { value: 3, done: false }
console.log(myIterator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

ജനറേറ്ററുകൾ

ജനറേറ്ററുകൾ ഇറ്ററേറ്ററുകൾ നിർവചിക്കുന്നതിന് കൂടുതൽ സംക്ഷിപ്തമായ ഒരു മാർഗ്ഗം നൽകുന്നു. അവ താൽക്കാലികമായി നിർത്താനും പുനരാരംഭിക്കാനും കഴിയുന്ന ഫംഗ്ഷനുകളാണ്, yield കീവേഡ് ഉപയോഗിച്ച് ഒരു ഇറ്ററേറ്റീവ് അൽഗോരിതം കൂടുതൽ സ്വാഭാവികമായി നിർവചിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

മുകളിലുള്ള അതേ ഉദാഹരണം, ഒരു ജനറേറ്റർ ഫംഗ്ഷൻ ഉപയോഗിച്ച് നടപ്പിലാക്കിയത് ഇതാ:

            
function* myGenerator(data) {
  for (let i = 0; i < data.length; i++) {
    yield data[i];
  }
}

const iterator = myGenerator([1, 2, 3]);

console.log(iterator.next()); // Output: { value: 1, done: false }
console.log(iterator.next()); // Output: { value: 2, done: false }
console.log(iterator.next()); // Output: { value: 3, done: false }
console.log(iterator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

yield കീവേഡ് ജനറേറ്റർ ഫംഗ്ഷൻ താൽക്കാലികമായി നിർത്തുകയും നിർദ്ദിഷ്ട മൂല്യം നൽകുകയും ചെയ്യുന്നു. ജനറേറ്റർ നിർത്തിയിടത്ത് നിന്ന് പിന്നീട് പുനരാരംഭിക്കാൻ കഴിയും.

അസിങ്ക് ഇറ്ററേറ്ററുകളെ പരിചയപ്പെടുത്തുന്നു

അസിങ്ക് ഇറ്ററേറ്ററുകൾ അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനായി ഇറ്ററേറ്ററുകളുടെ ആശയം വികസിപ്പിക്കുന്നു. ഒരു API-ൽ നിന്ന് ഡാറ്റ ലഭ്യമാക്കുകയോ ഒരു ഫയലിൽ നിന്ന് വായിക്കുകയോ പോലുള്ള ഓരോ ഘടകവും അസിൻക്രണസായി വീണ്ടെടുക്കുകയോ പ്രോസസ്സ് ചെയ്യുകയോ ചെയ്യുന്ന ഡാറ്റാ സ്ട്രീമുകളിൽ പ്രവർത്തിക്കാൻ അവ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്. ഇത് Node.js എൻവയോൺമെൻ്റുകളിലോ ബ്രൗസറിൽ അസിൻക്രണസ് ഡാറ്റ കൈകാര്യം ചെയ്യുമ്പോഴോ പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. ഇത് മികച്ച ഉപയോക്തൃ അനുഭവത്തിനായി റെസ്‌പോൺസീവ്നസ് വർദ്ധിപ്പിക്കുകയും ആഗോളതലത്തിൽ പ്രസക്തവുമാണ്.

ഒരു അസിങ്ക് ഇറ്ററേറ്റർ value, done എന്നീ പ്രോപ്പർട്ടികളുള്ള ഒരു ഒബ്ജക്റ്റിലേക്ക് റിസോൾവ് ചെയ്യുന്ന ഒരു പ്രോമിസ് നൽകുന്ന ഒരു next() മെത്തേഡ് നടപ്പിലാക്കുന്നു, ഇത് സിൻക്രണസ് ഇറ്ററേറ്ററുകൾക്ക് സമാനമാണ്. പ്രധാന വ്യത്യാസം, next() മെത്തേഡ് ഇപ്പോൾ ഒരു പ്രോമിസ് നൽകുന്നു എന്നതാണ്, ഇത് അസിൻക്രണസ് പ്രവർത്തനങ്ങൾക്ക് അനുവദിക്കുന്നു.

ഒരു അസിങ്ക് ഇറ്ററേറ്റർ നിർവചിക്കുന്നു

ഒരു അടിസ്ഥാന അസിങ്ക് ഇറ്ററേറ്ററിൻ്റെ ഉദാഹരണം ഇതാ:

            
const myAsyncIterator = {
  data: [1, 2, 3],
  index: 0,
  async next() {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate async operation
    if (this.index < this.data.length) {
      return { value: this.data[this.index++], done: false };
    } else {
      return { value: undefined, done: true };
    }
  },
};

async function consumeIterator() {
  console.log(await myAsyncIterator.next()); // Output: { value: 1, done: false }
  console.log(await myAsyncIterator.next()); // Output: { value: 2, done: false }
  console.log(await myAsyncIterator.next()); // Output: { value: 3, done: false }
  console.log(await myAsyncIterator.next()); // Output: { value: undefined, done: true }
}

consumeIterator();

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, next() മെത്തേഡ് setTimeout ഉപയോഗിച്ച് ഒരു അസിൻക്രണസ് പ്രവർത്തനം സിമുലേറ്റ് ചെയ്യുന്നു. consumeIterator ഫംഗ്ഷൻ പിന്നീട് ഫലം ലോഗ് ചെയ്യുന്നതിന് മുമ്പ് next() നൽകുന്ന പ്രോമിസ് റിസോൾവ് ചെയ്യുന്നതിനായി കാത്തിരിക്കാൻ await ഉപയോഗിക്കുന്നു.

അസിങ്ക് ജനറേറ്ററുകൾ

സിൻക്രണസ് ജനറേറ്ററുകൾക്ക് സമാനമായി, അസിങ്ക് ജനറേറ്ററുകൾ അസിങ്ക് ഇറ്ററേറ്ററുകൾ സൃഷ്ടിക്കാൻ കൂടുതൽ സൗകര്യപ്രദമായ ഒരു മാർഗ്ഗം നൽകുന്നു. അവ താൽക്കാലികമായി നിർത്താനും പുനരാരംഭിക്കാനും കഴിയുന്ന ഫംഗ്ഷനുകളാണ്, കൂടാതെ പ്രോമിസുകൾ നൽകാൻ അവ yield കീവേഡ് ഉപയോഗിക്കുന്നു.

ഒരു അസിങ്ക് ജനറേറ്റർ നിർവചിക്കാൻ, async function* സിൻ്റാക്സ് ഉപയോഗിക്കുക. ജനറേറ്ററിനുള്ളിൽ, അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ നടത്താൻ നിങ്ങൾക്ക് await കീവേഡ് ഉപയോഗിക്കാം.

മുകളിലുള്ള അതേ ഉദാഹരണം, ഒരു അസിങ്ക് ജനറേറ്റർ ഉപയോഗിച്ച് നടപ്പിലാക്കിയത് ഇതാ:

            
async function* myAsyncGenerator(data) {
  for (let i = 0; i < data.length; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate async operation
    yield data[i];
  }
}

async function consumeGenerator() {
  const iterator = myAsyncGenerator([1, 2, 3]);

  console.log(await iterator.next()); // Output: { value: 1, done: false }
  console.log(await iterator.next()); // Output: { value: 2, done: false }
  console.log(await iterator.next()); // Output: { value: 3, done: false }
  console.log(await iterator.next()); // Output: { value: undefined, done: true }
}

consumeGenerator();

            

              
                Copy
              
            
          

for await...of ഉപയോഗിച്ച് അസിങ്ക് ഇറ്ററേറ്ററുകൾ ഉപയോഗിക്കുന്നു

for await...of ലൂപ്പ് അസിങ്ക് ഇറ്ററേറ്ററുകൾ ഉപയോഗിക്കുന്നതിന് വൃത്തിയുള്ളതും വായിക്കാൻ എളുപ്പമുള്ളതുമായ ഒരു സിൻ്റാക്സ് നൽകുന്നു. ഇത് ഇറ്ററേറ്റർ നൽകുന്ന മൂല്യങ്ങളിലൂടെ സ്വയമേവ കടന്നുപോകുകയും ലൂപ്പ് ബോഡി എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പ് ഓരോ പ്രോമിസും റിസോൾവ് ചെയ്യുന്നതിനായി കാത്തിരിക്കുകയും ചെയ്യുന്നു. ഇത് അസിൻക്രണസ് കോഡ് ലളിതമാക്കുന്നു, ഇത് വായിക്കാനും പരിപാലിക്കാനും എളുപ്പമാക്കുന്നു. ഈ സവിശേഷത ആഗോളതലത്തിൽ വൃത്തിയുള്ളതും കൂടുതൽ വായിക്കാൻ കഴിയുന്നതുമായ അസിൻക്രണസ് വർക്ക്ഫ്ലോകളെ പ്രോത്സാഹിപ്പിക്കുന്നു.

മുമ്പത്തെ ഉദാഹരണത്തിലെ അസിങ്ക് ജനറേറ്ററിനൊപ്പം for await...of ഉപയോഗിക്കുന്നതിൻ്റെ ഒരു ഉദാഹരണം ഇതാ:

            
async function* myAsyncGenerator(data) {
  for (let i = 0; i < data.length; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate async operation
    yield data[i];
  }
}

async function consumeGenerator() {
  for await (const value of myAsyncGenerator([1, 2, 3])) {
    console.log(value); // Output: 1, 2, 3 (with a 500ms delay between each)
  }
}

consumeGenerator();

            

              
                Copy
              
            
          

for await...of ലൂപ്പ് അസിൻക്രണസ് ഇറ്ററേഷൻ പ്രക്രിയയെ കൂടുതൽ ലളിതവും മനസ്സിലാക്കാൻ എളുപ്പവുമാക്കുന്നു.

അസിങ്ക് ഇറ്ററേറ്ററുകളുടെ ഉപയോഗങ്ങൾ

അസിങ്ക് ഇറ്ററേറ്ററുകൾ അവിശ്വസനീയമാംവിധം വൈവിധ്യമാർന്നതും അസിൻക്രണസ് ഡാറ്റാ പ്രോസസ്സിംഗ് ആവശ്യമുള്ള വിവിധ സാഹചര്യങ്ങളിൽ പ്രയോഗിക്കാൻ കഴിയുന്നതുമാണ്. ചില സാധാരണ ഉപയോഗങ്ങൾ ഇതാ:

1. വലിയ ഫയലുകൾ വായിക്കുന്നു

വലിയ ഫയലുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ, മുഴുവൻ ഫയലും ഒരേസമയം മെമ്മറിയിലേക്ക് വായിക്കുന്നത് കാര്യക്ഷമമല്ലാത്തതും വിഭവങ്ങൾ ധാരാളം ഉപയോഗിക്കുന്നതുമാണ്. ഫയൽ ഭാഗങ്ങളായി അസിൻക്രണസായി വായിക്കുന്നതിനുള്ള ഒരു മാർഗ്ഗം അസിങ്ക് ഇറ്ററേറ്ററുകൾ നൽകുന്നു, ഓരോ ഭാഗവും ലഭ്യമാകുമ്പോൾ പ്രോസസ്സ് ചെയ്യുന്നു. ഇത് സെർവർ-സൈഡ് ആപ്ലിക്കേഷനുകൾക്കും Node.js എൻവയോൺമെൻ്റുകൾക്കും പ്രത്യേകിച്ചും പ്രധാനമാണ്.

            
const fs = require('fs');
const readline = require('readline');

async function* readLines(filePath) {
  const fileStream = fs.createReadStream(filePath);

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

async function processFile(filePath) {
  for await (const line of readLines(filePath)) {
    console.log(`Line: ${line}`);
    // Process each line asynchronously
  }
}

// Example usage
// processFile('path/to/large/file.txt');

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, readLines ഫംഗ്ഷൻ ഒരു ഫയൽ ഓരോ വരിയായി അസിൻക്രണസായി വായിക്കുന്നു, ഓരോ വരിയും വിളിക്കുന്നയാൾക്ക് നൽകുന്നു. processFile ഫംഗ്ഷൻ പിന്നീട് വരികൾ ഉപയോഗിക്കുകയും അവയെ അസിൻക്രണസായി പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു.

2. API-കളിൽ നിന്ന് ഡാറ്റ ലഭ്യമാക്കുന്നു

API-കളിൽ നിന്ന് ഡാറ്റ വീണ്ടെടുക്കുമ്പോൾ, പ്രത്യേകിച്ച് പേജിനേഷൻ അല്ലെങ്കിൽ വലിയ ഡാറ്റാസെറ്റുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ, ഡാറ്റ ഭാഗങ്ങളായി ലഭ്യമാക്കാനും പ്രോസസ്സ് ചെയ്യാനും അസിങ്ക് ഇറ്ററേറ്ററുകൾ ഉപയോഗിക്കാം. ഇത് മുഴുവൻ ഡാറ്റാസെറ്റും ഒരേസമയം മെമ്മറിയിലേക്ക് ലോഡുചെയ്യുന്നത് ഒഴിവാക്കാനും അത് ക്രമേണ പ്രോസസ്സ് ചെയ്യാനും നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് വലിയ ഡാറ്റാസെറ്റുകളിൽ പോലും റെസ്‌പോൺസീവ്നസ് ഉറപ്പാക്കുന്നു, വ്യത്യസ്ത ഇൻ്റർനെറ്റ് വേഗതയിലും പ്രദേശങ്ങളിലും ഉടനീളം ഉപയോക്തൃ അനുഭവം മെച്ചപ്പെടുത്തുന്നു.

            
async function* fetchPaginatedData(url) {
  let nextUrl = url;

  while (nextUrl) {
    const response = await fetch(nextUrl);
    const data = await response.json();

    for (const item of data.results) {
      yield item;
    }

    nextUrl = data.next;
  }
}

async function processData() {
  for await (const item of fetchPaginatedData('https://api.example.com/data')) {
    console.log(item);
    // Process each item asynchronously
  }
}

// Example usage
// processData();

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, fetchPaginatedData ഫംഗ്ഷൻ ഒരു പേജിനേറ്റഡ് API എൻഡ്പോയിൻ്റിൽ നിന്ന് ഡാറ്റ ലഭ്യമാക്കുന്നു, ഓരോ ഇനവും വിളിക്കുന്നയാൾക്ക് നൽകുന്നു. processData ഫംഗ്ഷൻ പിന്നീട് ഇനങ്ങൾ ഉപയോഗിക്കുകയും അവയെ അസിൻക്രണസായി പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു.

3. റിയൽ-ടൈം ഡാറ്റാ സ്ട്രീമുകൾ കൈകാര്യം ചെയ്യുന്നു

അസിങ്ക് ഇറ്ററേറ്ററുകൾ വെബ്സോക്കറ്റുകളിൽ നിന്നോ സെർവർ-സെൻ്റ് ഇവൻ്റുകളിൽ നിന്നോ ഉള്ള പോലുള്ള റിയൽ-ടൈം ഡാറ്റാ സ്ട്രീമുകൾ കൈകാര്യം ചെയ്യുന്നതിനും അനുയോജ്യമാണ്. പ്രധാന ത്രെഡിനെ ബ്ലോക്ക് ചെയ്യാതെ, വരുന്ന ഡാറ്റ എത്തുമ്പോൾ തന്നെ പ്രോസസ്സ് ചെയ്യാൻ അവ നിങ്ങളെ അനുവദിക്കുന്നു. റെസ്‌പോൺസീവും സ്കെയിലബിളുമായ റിയൽ-ടൈം ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിന് ഇത് നിർണായകമാണ്, ഓരോ സെക്കൻഡിലും അപ്‌ഡേറ്റുകൾ ആവശ്യമുള്ള സേവനങ്ങൾക്ക് ഇത് അത്യന്താപേക്ഷിതമാണ്.

            
async function* processWebSocketStream(socket) {
  while (true) {
    const message = await new Promise((resolve, reject) => {
      socket.onmessage = (event) => {
        resolve(event.data);
      };
      socket.onerror = (error) => {
        reject(error);
      };
    });

    yield message;
  }
}

async function consumeWebSocketStream(socket) {
  for await (const message of processWebSocketStream(socket)) {
    console.log(`Received message: ${message}`);
    // Process each message asynchronously
  }
}

// Example usage
// const socket = new WebSocket('ws://example.com/socket');
// consumeWebSocketStream(socket);

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, processWebSocketStream ഫംഗ്ഷൻ ഒരു വെബ്സോക്കറ്റ് കണക്ഷനിൽ നിന്നുള്ള സന്ദേശങ്ങൾക്കായി കാത്തിരിക്കുകയും ഓരോ സന്ദേശവും വിളിക്കുന്നയാൾക്ക് നൽകുകയും ചെയ്യുന്നു. consumeWebSocketStream ഫംഗ്ഷൻ പിന്നീട് സന്ദേശങ്ങൾ ഉപയോഗിക്കുകയും അവയെ അസിൻക്രണസായി പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു.

4. ഇവൻ്റ്-ഡ്രിവൺ ആർക്കിടെക്ചറുകൾ

ഇവൻ്റുകൾ അസിൻക്രണസായി പ്രോസസ്സ് ചെയ്യുന്നതിന് ഇവൻ്റ്-ഡ്രിവൺ ആർക്കിടെക്ചറുകളിലേക്ക് അസിങ്ക് ഇറ്ററേറ്ററുകൾ സംയോജിപ്പിക്കാൻ കഴിയും. പ്രധാന ത്രെഡിനെ ബ്ലോക്ക് ചെയ്യാതെ, റിയൽ-ടൈമിൽ ഇവൻ്റുകളോട് പ്രതികരിക്കുന്ന സിസ്റ്റങ്ങൾ നിർമ്മിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഉപയോക്തൃ പ്രവർത്തനങ്ങളോടോ സിസ്റ്റം ഇവൻ്റുകളോടോ വേഗത്തിൽ പ്രതികരിക്കേണ്ട ആധുനികവും സ്കെയിലബിളുമായ ആപ്ലിക്കേഷനുകൾക്ക് ഇവൻ്റ്-ഡ്രിവൺ ആർക്കിടെക്ചറുകൾ നിർണായകമാണ്.

            
const EventEmitter = require('events');

async function* eventStream(emitter, eventName) {
  while (true) {
    const value = await new Promise(resolve => {
      emitter.once(eventName, resolve);
    });
    yield value;
  }
}

async function consumeEventStream(emitter, eventName) {
  for await (const event of eventStream(emitter, eventName)) {
    console.log(`Received event: ${event}`);
    // Process each event asynchronously
  }
}

// Example usage
// const myEmitter = new EventEmitter();
// consumeEventStream(myEmitter, 'data');

// myEmitter.emit('data', 'Event data 1');
// myEmitter.emit('data', 'Event data 2');

            

              
                Copy
              
            
          

ഈ ഉദാഹരണം ഒരു EventEmitter പുറത്തുവിടുന്ന ഇവൻ്റുകൾക്കായി കാത്തിരിക്കുന്ന ഒരു അസിൻക്രണസ് ഇറ്ററേറ്റർ സൃഷ്ടിക്കുന്നു. ഓരോ ഇവൻ്റും ഉപഭോക്താവിന് നൽകുന്നു, ഇത് ഇവൻ്റുകളുടെ അസിൻക്രണസ് പ്രോസസ്സിംഗിന് അനുവദിക്കുന്നു. ഇവൻ്റ്-ഡ്രിവൺ ആർക്കിടെക്ചറുകളുമായുള്ള സംയോജനം മോഡുലാറും റിയാക്ടീവുമായ സിസ്റ്റങ്ങൾക്ക് അനുവദിക്കുന്നു.

അസിങ്ക് ഇറ്ററേറ്ററുകൾ ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോജനങ്ങൾ

അസിങ്ക് ഇറ്ററേറ്ററുകൾ പരമ്പരാഗത അസിൻക്രണസ് പ്രോഗ്രാമിംഗ് ടെക്നിക്കുകളേക്കാൾ നിരവധി ഗുണങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു, ഇത് ആധുനിക ജാവാസ്ക്രിപ്റ്റ് ഡെവലപ്‌മെൻ്റിന് ഒരു വിലപ്പെട്ട ഉപകരണമാക്കി മാറ്റുന്നു. ഈ ഗുണങ്ങൾ കൂടുതൽ കാര്യക്ഷമവും റെസ്‌പോൺസീവും സ്കെയിലബിളുമായ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നതിന് നേരിട്ട് സംഭാവന നൽകുന്നു.

1. മെച്ചപ്പെട്ട പ്രകടനം

ഡാറ്റ ഭാഗങ്ങളായി അസിൻക്രണസായി പ്രോസസ്സ് ചെയ്യുന്നതിലൂടെ, അസിങ്ക് ഇറ്ററേറ്ററുകൾക്ക് ഡാറ്റാ-ഇൻ്റൻസീവ് ആപ്ലിക്കേഷനുകളുടെ പ്രകടനം മെച്ചപ്പെടുത്താൻ കഴിയും. അവ മുഴുവൻ ഡാറ്റാസെറ്റും ഒരേസമയം മെമ്മറിയിലേക്ക് ലോഡുചെയ്യുന്നത് ഒഴിവാക്കുന്നു, മെമ്മറി ഉപഭോഗം കുറയ്ക്കുകയും റെസ്‌പോൺസീവ്നസ് മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു. വലിയ ഡാറ്റാസെറ്റുകളോ റിയൽ-ടൈം ഡാറ്റാ സ്ട്രീമുകളോ കൈകാര്യം ചെയ്യുന്ന ആപ്ലിക്കേഷനുകൾക്ക് ഇത് പ്രത്യേകിച്ചും നിർണായകമാണ്, അവ ലോഡിന് കീഴിലും മികച്ച പ്രകടനം കാഴ്ചവയ്ക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

2. മെച്ചപ്പെട്ട റെസ്‌പോൺസീവ്നസ്

പ്രധാന ത്രെഡിനെ ബ്ലോക്ക് ചെയ്യാതെ ഡാറ്റ പ്രോസസ്സ് ചെയ്യാൻ അസിങ്ക് ഇറ്ററേറ്ററുകൾ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ഉപയോക്തൃ ഇടപെടലുകളോട് റെസ്‌പോൺസീവായി തുടരുന്നുവെന്ന് ഉറപ്പാക്കുന്നു. ഇത് വെബ് ആപ്ലിക്കേഷനുകൾക്ക് പ്രത്യേകിച്ചും പ്രധാനമാണ്, അവിടെ നല്ല ഉപയോക്തൃ അനുഭവത്തിന് റെസ്‌പോൺസീവായ ഒരു യൂസർ ഇൻ്റർഫേസ് നിർണായകമാണ്. വിവിധ ഇൻ്റർനെറ്റ് വേഗതയുള്ള ആഗോള ഉപയോക്താക്കൾ ആപ്ലിക്കേഷൻ്റെ റെസ്‌പോൺസീവ്നസ് വിലമതിക്കും.

3. ലളിതമായ അസിൻക്രണസ് കോഡ്

അസിങ്ക് ഇറ്ററേറ്ററുകൾ, for await...of ലൂപ്പുമായി ചേർന്ന്, അസിൻക്രണസ് ഡാറ്റാ സ്ട്രീമുകളിൽ പ്രവർത്തിക്കാൻ വൃത്തിയുള്ളതും വായിക്കാൻ എളുപ്പമുള്ളതുമായ ഒരു സിൻ്റാക്സ് നൽകുന്നു. ഇത് അസിൻക്രണസ് കോഡ് മനസ്സിലാക്കാനും പരിപാലിക്കാനും എളുപ്പമാക്കുന്നു, പിശകുകളുടെ സാധ്യത കുറയ്ക്കുന്നു. ലളിതമായ സിൻ്റാക്സ് ഡെവലപ്പർമാരെ അസിൻക്രണസ് പ്രോഗ്രാമിംഗിൻ്റെ സങ്കീർണ്ണതകളേക്കാൾ അവരുടെ ആപ്ലിക്കേഷനുകളുടെ ലോജിക്കിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ അനുവദിക്കുന്നു.

4. ബാക്ക്പ്രഷർ ഹാൻഡ്‌ലിംഗ്

അസിങ്ക് ഇറ്ററേറ്ററുകൾ സ്വാഭാവികമായും ബാക്ക്പ്രഷർ ഹാൻഡ്‌ലിംഗിനെ പിന്തുണയ്ക്കുന്നു, ഇത് ഡാറ്റ ഉൽപ്പാദിപ്പിക്കുകയും ഉപയോഗിക്കുകയും ചെയ്യുന്ന നിരക്ക് നിയന്ത്രിക്കാനുള്ള കഴിവാണ്. ഡാറ്റയുടെ പ്രളയത്തിൽ നിങ്ങളുടെ ആപ്ലിക്കേഷൻ തകരാതെ തടയുന്നതിന് ഇത് പ്രധാനമാണ്. കൂടുതൽ ഡാറ്റയ്ക്ക് തയ്യാറാകുമ്പോൾ ഉൽപ്പാദകർക്ക് സൂചന നൽകാൻ ഉപഭോക്താക്കളെ അനുവദിക്കുന്നതിലൂടെ, ഉയർന്ന ലോഡിന് കീഴിൽ നിങ്ങളുടെ ആപ്ലിക്കേഷൻ സ്ഥിരവും മികച്ച പ്രകടനവും നിലനിർത്തുന്നുവെന്ന് ഉറപ്പാക്കാൻ അസിങ്ക് ഇറ്ററേറ്ററുകൾക്ക് സഹായിക്കാനാകും. റിയൽ-ടൈം ഡാറ്റാ സ്ട്രീമുകളോ ഉയർന്ന അളവിലുള്ള ഡാറ്റാ പ്രോസസ്സിംഗോ കൈകാര്യം ചെയ്യുമ്പോൾ ബാക്ക്പ്രഷർ പ്രത്യേകിച്ചും പ്രധാനമാണ്, ഇത് സിസ്റ്റം സ്ഥിരത ഉറപ്പാക്കുന്നു.

അസിങ്ക് ഇറ്ററേറ്ററുകൾ ഉപയോഗിക്കുന്നതിനുള്ള മികച്ച രീതികൾ

അസിങ്ക് ഇറ്ററേറ്ററുകൾ പരമാവധി പ്രയോജനപ്പെടുത്തുന്നതിന്, ചില മികച്ച രീതികൾ പിന്തുടരേണ്ടത് പ്രധാനമാണ്. ഈ മാർഗ്ഗനിർദ്ദേശങ്ങൾ നിങ്ങളുടെ കോഡ് കാര്യക്ഷമവും പരിപാലിക്കാവുന്നതും കരുത്തുറ്റതുമാണെന്ന് ഉറപ്പാക്കാൻ സഹായിക്കും.

1. പിശകുകൾ ശരിയായി കൈകാര്യം ചെയ്യുക

അസിൻക്രണസ് പ്രവർത്തനങ്ങളിൽ പ്രവർത്തിക്കുമ്പോൾ, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ക്രാഷാകുന്നത് തടയാൻ പിശകുകൾ ശരിയായി കൈകാര്യം ചെയ്യേണ്ടത് പ്രധാനമാണ്. അസിൻക്രണസ് ഇറ്ററേഷൻ സമയത്ത് ഉണ്ടാകാനിടയുള്ള ഏതെങ്കിലും പിശകുകൾ പിടിക്കാൻ try...catch ബ്ലോക്കുകൾ ഉപയോഗിക്കുക. ശരിയായ പിശക് കൈകാര്യം ചെയ്യൽ അപ്രതീക്ഷിത പ്രശ്നങ്ങൾ നേരിടുമ്പോഴും നിങ്ങളുടെ ആപ്ലിക്കേഷൻ സ്ഥിരമായി തുടരുന്നുവെന്ന് ഉറപ്പാക്കുന്നു, ഇത് കൂടുതൽ കരുത്തുറ്റ ഉപയോക്തൃ അനുഭവത്തിന് സംഭാവന നൽകുന്നു.

            
async function consumeGenerator() {
  try {
    for await (const value of myAsyncGenerator([1, 2, 3])) {
      console.log(value);
    }
  } catch (error) {
    console.error(`An error occurred: ${error}`);
    // Handle the error
  }
}

            

              
                Copy
              
            
          

2. ബ്ലോക്കിംഗ് പ്രവർത്തനങ്ങൾ ഒഴിവാക്കുക

നിങ്ങളുടെ അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ യഥാർത്ഥത്തിൽ നോൺ-ബ്ലോക്കിംഗ് ആണെന്ന് ഉറപ്പാക്കുക. നിങ്ങളുടെ അസിങ്ക് ഇറ്ററേറ്ററുകൾക്കുള്ളിൽ ദീർഘനേരം പ്രവർത്തിക്കുന്ന സിൻക്രണസ് പ്രവർത്തനങ്ങൾ നടത്തുന്നത് ഒഴിവാക്കുക, കാരണം ഇത് അസിൻക്രണസ് പ്രോസസ്സിംഗിൻ്റെ പ്രയോജനങ്ങൾ ഇല്ലാതാക്കും. നോൺ-ബ്ലോക്കിംഗ് പ്രവർത്തനങ്ങൾ പ്രധാന ത്രെഡ് റെസ്‌പോൺസീവായി തുടരുന്നുവെന്ന് ഉറപ്പാക്കുന്നു, ഇത് പ്രത്യേകിച്ചും വെബ് ആപ്ലിക്കേഷനുകളിൽ മികച്ച ഉപയോക്തൃ അനുഭവം നൽകുന്നു.

3. കോൺകറൻസി പരിമിതപ്പെടുത്തുക

ഒന്നിലധികം അസിങ്ക് ഇറ്ററേറ്ററുകളിൽ പ്രവർത്തിക്കുമ്പോൾ, ഒരേസമയം നടക്കുന്ന പ്രവർത്തനങ്ങളുടെ എണ്ണത്തിൽ ശ്രദ്ധിക്കുക. കോൺകറൻസി പരിമിധപ്പെടുത്തുന്നത് ഒരേസമയം നിരവധി ടാസ്ക്കുകളാൽ നിങ്ങളുടെ ആപ്ലിക്കേഷൻ തകരാതെ തടയാൻ കഴിയും. വിഭവ-സാന്ദ്രമായ പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുമ്പോഴോ പരിമിതമായ വിഭവങ്ങളുള്ള എൻവയോൺമെൻ്റുകളിൽ പ്രവർത്തിക്കുമ്പോഴോ ഇത് പ്രത്യേകിച്ചും പ്രധാനമാണ്. മെമ്മറി എക്സ്ഹോഷൻ, പ്രകടനത്തകർച്ച തുടങ്ങിയ പ്രശ്നങ്ങൾ ഒഴിവാക്കാൻ ഇത് സഹായിക്കുന്നു.

4. വിഭവങ്ങൾ വൃത്തിയാക്കുക

നിങ്ങൾ ഒരു അസിങ്ക് ഇറ്ററേറ്റർ ഉപയോഗിച്ച് കഴിയുമ്പോൾ, ഫയൽ ഹാൻഡിലുകൾ അല്ലെങ്കിൽ നെറ്റ്‌വർക്ക് കണക്ഷനുകൾ പോലുള്ള അത് ഉപയോഗിക്കുന്ന ഏതെങ്കിലും വിഭവങ്ങൾ വൃത്തിയാക്കുന്നുവെന്ന് ഉറപ്പാക്കുക. ഇത് വിഭവങ്ങളുടെ ചോർച്ച തടയാനും നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ മൊത്തത്തിലുള്ള സ്ഥിരത മെച്ചപ്പെടുത്താനും സഹായിക്കും. ദീർഘകാലം പ്രവർത്തിക്കുന്ന ആപ്ലിക്കേഷനുകൾക്കോ സേവനങ്ങൾക്കോ ശരിയായ വിഭവ മാനേജ്മെൻ്റ് നിർണായകമാണ്, അവ കാലക്രമേണ സ്ഥിരമായി തുടരുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

5. സങ്കീർണ്ണമായ ലോജിക്കിനായി അസിങ്ക് ജനറേറ്ററുകൾ ഉപയോഗിക്കുക

കൂടുതൽ സങ്കീർണ്ണമായ ഇറ്ററേറ്റീവ് ലോജിക്കിനായി, അസിങ്ക് ജനറേറ്ററുകൾ അസിങ്ക് ഇറ്ററേറ്ററുകൾ നിർവചിക്കാൻ വൃത്തിയുള്ളതും കൂടുതൽ പരിപാലിക്കാവുന്നതുമായ ഒരു മാർഗ്ഗം നൽകുന്നു. ജനറേറ്റർ ഫംഗ്ഷൻ താൽക്കാലികമായി നിർത്താനും പുനരാരംഭിക്കാനും yield കീവേഡ് ഉപയോഗിക്കാൻ അവ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് നിയന്ത്രണത്തിൻ്റെ ഒഴുക്കിനെക്കുറിച്ച് ചിന്തിക്കാൻ എളുപ്പമാക്കുന്നു. ഇറ്ററേറ്റീവ് ലോജിക്കിൽ ഒന്നിലധികം അസിൻക്രണസ് ഘട്ടങ്ങളോ കണ്ടീഷണൽ ബ്രാഞ്ചിംഗോ ഉൾപ്പെടുമ്പോൾ അസിങ്ക് ജനറേറ്ററുകൾ പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

അസിങ്ക് ഇറ്ററേറ്ററുകളും ഒബ്സെർവബിൾസും

അസിങ്ക് ഇറ്ററേറ്ററുകളും ഒബ്സെർവബിൾസും അസിൻക്രണസ് ഡാറ്റാ സ്ട്രീമുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള പാറ്റേണുകളാണ്, എന്നാൽ അവയ്ക്ക് വ്യത്യസ്ത സ്വഭാവങ്ങളും ഉപയോഗങ്ങളും ഉണ്ട്.

അസിങ്ക് ഇറ്ററേറ്ററുകൾ

• പുൾ-ബേസ്ഡ്: ഉപഭോക്താവ് ഇറ്ററേറ്ററിൽ നിന്ന് അടുത്ത മൂല്യം വ്യക്തമായി അഭ്യർത്ഥിക്കുന്നു.
• ഒറ്റ സബ്സ്ക്രിപ്ഷൻ: ഓരോ ഇറ്ററേറ്ററും ഒരു തവണ മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ.
• ജാവാസ്ക്രിപ്റ്റിൽ ഇൻ-ബിൽറ്റ് പിന്തുണ: അസിങ്ക് ഇറ്ററേറ്ററുകളും for await...of-ഉം ഭാഷാ സ്പെസിഫിക്കേഷൻ്റെ ഭാഗമാണ്.

ഒബ്സെർവബിൾസ്

• പുഷ്-ബേസ്ഡ്: ഉൽപ്പാദകൻ ഉപഭോക്താവിന് മൂല്യങ്ങൾ പുഷ് ചെയ്യുന്നു.
• ഒന്നിലധികം സബ്സ്ക്രിപ്ഷനുകൾ: ഒരു ഒബ്സെർവബിളിലേക്ക് ഒന്നിലധികം ഉപഭോക്താക്കൾക്ക് സബ്സ്ക്രൈബ് ചെയ്യാൻ കഴിയും.
• ഒരു ലൈബ്രറി ആവശ്യമാണ്: ഒബ്സെർവബിൾസ് സാധാരണയായി RxJS പോലുള്ള ഒരു ലൈബ്രറി ഉപയോഗിച്ചാണ് നടപ്പിലാക്കുന്നത്.

ഉപഭോക്താവിന് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്ന നിരക്ക് നിയന്ത്രിക്കേണ്ട സാഹചര്യങ്ങളിൽ അസിങ്ക് ഇറ്ററേറ്ററുകൾ വളരെ അനുയോജ്യമാണ്, ഉദാഹരണത്തിന് വലിയ ഫയലുകൾ വായിക്കുകയോ പേജിനേറ്റഡ് API-കളിൽ നിന്ന് ഡാറ്റ ലഭ്യമാക്കുകയോ ചെയ്യുമ്പോൾ. ഉൽപ്പാദകന് ഒന്നിലധികം ഉപഭോക്താക്കൾക്ക് ഡാറ്റ പുഷ് ചെയ്യേണ്ട സാഹചര്യങ്ങളിൽ ഒബ്സെർവബിൾസ് കൂടുതൽ അനുയോജ്യമാണ്, ഉദാഹരണത്തിന് റിയൽ-ടൈം ഡാറ്റാ സ്ട്രീമുകളോ ഇവൻ്റ്-ഡ്രിവൺ ആർക്കിടെക്ചറുകളോ. അസിങ്ക് ഇറ്ററേറ്ററുകളും ഒബ്സെർവബിൾസും തമ്മിൽ തിരഞ്ഞെടുക്കുന്നത് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ പ്രത്യേക ആവശ്യങ്ങളും ആവശ്യകതകളും അനുസരിച്ചായിരിക്കും.

ഉപസംഹാരം

ജാവാസ്ക്രിപ്റ്റ് അസിങ്ക് ഇറ്ററേറ്റർ പാറ്റേൺ അസിൻക്രണസ് ഡാറ്റാ സ്ട്രീമുകൾ കൈകാര്യം ചെയ്യുന്നതിന് ശക്തവും ലളിതവുമായ ഒരു പരിഹാരം നൽകുന്നു. ഡാറ്റ ഭാഗങ്ങളായി അസിൻക്രണസായി പ്രോസസ്സ് ചെയ്യുന്നതിലൂടെ, അസിങ്ക് ഇറ്ററേറ്ററുകൾക്ക് നിങ്ങളുടെ ആപ്ലിക്കേഷനുകളുടെ പ്രകടനവും റെസ്‌പോൺസീവ്നസും മെച്ചപ്പെടുത്താൻ കഴിയും. for await...of ലൂപ്പും അസിങ്ക് ജനറേറ്ററുകളുമായി ചേർന്ന്, അവ അസിൻക്രണസ് ഡാറ്റയുമായി പ്രവർത്തിക്കാൻ വൃത്തിയുള്ളതും വായിക്കാൻ എളുപ്പമുള്ളതുമായ ഒരു സിൻ്റാക്സ് നൽകുന്നു. ഈ ബ്ലോഗ് പോസ്റ്റിൽ വിവരിച്ചിട്ടുള്ള മികച്ച രീതികൾ പിന്തുടരുന്നതിലൂടെ, കാര്യക്ഷമവും പരിപാലിക്കാവുന്നതും കരുത്തുറ്റതുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ നിങ്ങൾക്ക് അസിങ്ക് ഇറ്ററേറ്ററുകളുടെ മുഴുവൻ കഴിവുകളും പ്രയോജനപ്പെടുത്താം.

നിങ്ങൾ വലിയ ഫയലുകൾ കൈകാര്യം ചെയ്യുകയാണെങ്കിലും, API-കളിൽ നിന്ന് ഡാറ്റ ലഭ്യമാക്കുകയാണെങ്കിലും, റിയൽ-ടൈം ഡാറ്റാ സ്ട്രീമുകൾ കൈകാര്യം ചെയ്യുകയാണെങ്കിലും, അല്ലെങ്കിൽ ഇവൻ്റ്-ഡ്രിവൺ ആർക്കിടെക്ചറുകൾ നിർമ്മിക്കുകയാണെങ്കിലും, മികച്ച അസിൻക്രണസ് കോഡ് എഴുതാൻ അസിങ്ക് ഇറ്ററേറ്ററുകൾക്ക് നിങ്ങളെ സഹായിക്കാനാകും. നിങ്ങളുടെ ജാവാസ്ക്രിപ്റ്റ് ഡെവലപ്‌മെൻ്റ് കഴിവുകൾ മെച്ചപ്പെടുത്തുന്നതിനും ആഗോള പ്രേക്ഷകർക്കായി കൂടുതൽ കാര്യക്ഷമവും റെസ്‌പോൺസീവുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനും ഈ പാറ്റേൺ സ്വീകരിക്കുക.